// HTTP SSE 接口请求
// 请求地址：https://wss.lke.cloud.tencent.com/v1/qbot/chat/sse
// 请求方式：POST

import Vue from 'vue';
// import clone from 'clone';
import { v4 as uuidv4 } from 'uuid';
import { MESSAGE_TYPE, APP_TYPE, APP_KEY } from '@/constants';
import { fetchEventSource } from '@microsoft/fetch-event-source';
import { arrayUnique, isJSON, getClarifyQuestion } from '@/utils/util';

const $e = Vue.prototype.$eventHub;

const origin = process.env.SSE_BASE_URL;
let path = '/v1/qbot/chat/sse';
let sseUrl = origin + path;

// let systemEventEmit = (eventName, data) => {
//     Vue.prototype.$eventHub.$emit(eventName, data);
// };

let cache = null; // 缓存
let timeoutTasks = {}; // 超时任务管理
const msgSendTimeout = 2 * 60 * 1000; // 发送消息超时ms，此处超时默认为2min
let sseObj = null; // 暂存当前sse请求对象

class SseCls {
    constructor () {
        cache = {
            session_id: 'session_id', // 会话ID
            configInfo: null, // 配置信息
            chatsContent: [], // 会话聊天内容
            systemEvents: [], // 系统事件栈
            transferInfo: {
                transferStatus: false,
                transferAvatar: ''
            } // 当前转人工状态
        };
    }
    init () {
        // 获取基础配置
        this.sseQueryConfigInfo();
    }
    // 获取基础配置
    async sseQueryConfigInfo () {
        try {
            const seatBizId = 'seat_biz_id';
            const sessionId = 'session_id';
            cache.seat_biz_id = seatBizId;
            cache.session_id = sessionId;
            // 接着获取机器人基础信息
            const botInfo = {
                'code': 0,
                'data': {
                    'name': '创新院小助手',
                    'avatar': 'https://qbot-1251316161.cos.ap-nanjing.myqcloud.com/avatar.png',
                    'is_available': true,
                    'bot_biz_id': '1664519736704069632'
                }
            };
            cache.configInfo = botInfo.data;
            cache.configInfo.session_id = sessionId;
            console.log('【sse】init config info:', cache.configInfo);
            $e.$emit('client_configChange', cache.configInfo);
        } catch (e) {
            Vue.prototype.$message.error('获取会话信息失败，请刷新页面重试！');
        }
    }

    // 获取全局配置信息
    getConfigInfo () {
        return cache.configInfo;
    }
    // 获取消息队列数据
    getChatsContent () {
        return cache.chatsContent || [];
    }
    // 根据msgId获取消息
    getMsgById (msgId) {
        const findedMsg = cache.chatsContent.find((r) => r.record_id === msgId);
        return findedMsg;
    }
    // 根据msgId获取其关联问题消息
    getQmsgById (msgId) {
        let findedQmsg = null;
        const findedMsg = this.getMsgById(msgId);

        if (findedMsg) {
            findedQmsg = cache.chatsContent.find((r) => (r.record_id === findedMsg.related_record_id));
        }

        return findedQmsg;
    }
    // 修改指定msgId的消息内容
    modifyMsgContent (msgId) {
        const findedMsg = this.getMsgById(msgId);

        if (findedMsg) {
            findedMsg.is_final = true;
            findedMsg.content = findedMsg.content.concat(`<span class="stop-ws">| 已停止生成</span>`);
            // todo
            $e.$emit('client_msgContentChange', {
                chatsContent: cache.chatsContent,
                type: MESSAGE_TYPE.STOP // ”停止生成“事件
            });
        }
    }
    getShowType (item) {
        // 展示种类 md json lke
        if (item.name === 'thought') {
            return 'md';
        } else if (item.status === 'success') {
            // 在clientData处还有特殊处理
            // 原来为lke-reference，现在区分两块处理，一块搜索类型参考来源，一块为qa doc参考来源，主要区别为字段内部数据定义和处理差异
            // 只能判断搜索 这块唯一标识取  index 将index转id
            if (item.debugging && item.debugging.display_type === 1) {
                return 'search-reference';
            } else if (item.debugging && item.debugging.display_type === 2) {
            // 只能qa和doc 这块唯一标识取  id
                return 'knowledge-reference';
            } else {
                return 'json';
            }
        } else {
            return 'json';
        }
    }
    handeLittleTagsData (quote_infos, references, content) {
        let res = '';
        if (quote_infos && quote_infos.length > 0) {
            const quoteMock = quote_infos.reduce((acc, curr) => {
                const existingItem = acc.find(item => item.position === curr.position);
                let res = {};
                if (references && references.length > 0) {
                    res = references.find(i => i.id === curr.index.toString());
                }
                if (existingItem) {
                    existingItem.tag.push({...res, id: curr.index});
                } else {
                    acc.push({
                        'tag': [{...res, id: curr.index}],
                        'position': curr.position
                    });
                }
                return acc;
            }, []);

            // data.quote_infos = quoteMock.sort((a, b) => b.position - a.position);
            let sortQuote = quoteMock.sort((a, b) => b.position - a.position);
            // 遍历数组，对每个元素进行操作
            sortQuote.forEach(item => {
                // 提取id数组并转换为字符串
                const tagIds = item.tag.map(tag => tag.id);
                const tagString = `[${tagIds.join(',')}](@ref)`;

                // 在指定位置插入字符串
                res = content.slice(0, item.position) + tagString + content.slice(item.position);
            });
            // console.error('0000000000000000handeLittleTagsData', res);

            return res;
        } else {
            return content;
        }
    }
    // sse 消息处理
    async getQASse (data, requestId) {
        let that = this;
        console.log('【sse】getQASse', data, requestId);
        const params = {
            'request_id': requestId,
            'content': data,
            'bot_app_key': APP_KEY,
            'visitor_biz_id': '1664519736704069632',
            'session_id': 'session_id',
            'visitor_labels': []
        };
        try {
            sseObj = await fetchEventSource(sseUrl, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(params),
                openWhenHidden: true,
                onopen (response) {
                    console.log('【sse】Connection opened:', response);
                },
                onmessage (rsp) {
                    console.log('【sse】Message from server:', rsp);
                    const event = JSON.parse(rsp.data);
                    // 处理reply
                    if (event.type === 'reply') {
                        let data = event.payload;
                        if (data.session_id !== cache.session_id) return; // 若新消息不属于当前机器人时，则不做处理

                        const findedMsg = that.getMsgById(data.record_id);
                        if (findedMsg && findedMsg.is_final) return; // 若消息已经”停止生成“，则新消息抛弃

                        that.assembleMsgContent(data, MESSAGE_TYPE.ANSWER);
                    }

                    // token_stat
                    if (event.type === 'token_stat') {
                        let data = event.payload;
                        $e.$emit('token_state_change', data);
                        if (data.session_id !== cache.session_id) return; // 若新消息不属于当前机器人时，则不做处理
                        let loadingMsg = cache.chatsContent.find((el) => el.loading_message);
                        let loadingText = '思考中';
                        // console.log('【vvvvvvvvvvvvvvvvvvvvvvvvvvv】', loadingMsg, window.webimToken[0].pattern);
                        if (loadingMsg) {
                            if (data.procedures && data.procedures.length > 0) {
                                loadingText =
                                    data.procedures[data.procedures.length - 1].title || '思考中';
                            }
                            let currentList = cache.chatsContent;
                            currentList.forEach((el) => {
                                if (el.loading_message) {
                                    el.text = loadingText;
                                    el.record_id = data.record_id;
                                    el.tokens_msg = data;
                                    // 只有标准模式加这个
                                    if (window.webimToken[0].pattern === 'standard') {
                                        el.is_final = false;
                                    }
                                }
                            });
                            // console.error(
                            //     'token_stat------loading------->',
                            //     data,
                            //     clone(cache.chatsContent)
                            // );
                            $e.$emit('client_msgContentChange', {
                                chatsContent: cache.chatsContent,
                                type: MESSAGE_TYPE.ANSWER
                            });
                        } else {
                            let findedMsg = cache.chatsContent.find(
                                (el) => el.record_id === data.record_id
                            );
                            // console.error('token_stat-----1111111-------->', findedMsg);
                            if (!findedMsg) return;
                            findedMsg.tokens_msg = data;
                            // console.error('token_stat-----22222222-------->', findedMsg);

                            // console.error(
                            //     'token_stat-----all list--===============-->',
                            //     cache.chatsContent
                            // );
                            $e.$emit('client_msgContentChange', {
                                chatsContent: cache.chatsContent,
                                type: MESSAGE_TYPE.ANSWER
                            });
                        }
                    }
                    // 处理thought
                    if (event.type === 'thought') {
                        let data = event.payload;
                        if (data.session_id !== cache.session_id) return; // 若新消息不属于当前机器人时，则不做处理
                        // let loadingMsg = cache.chatsContent.find((el) => el.loading_message);
                        // console.log(data.record_id);
                        // console.log(cache.chatsContent[1].record_id);
                        const findedMsg = cache.chatsContent.find(
                            (el) => el.record_id === data.record_id
                        );
                        console.error('【thought】-----1111111-------->', findedMsg);
                        if (!findedMsg) return;
                        if (data && data.procedures && data.procedures.length > 0) {
                            data.procedures.forEach(el => {
                                el.show_type = that.getShowType(el);
                                if (that.getShowType(el) === 'search-reference') {
                                    let quote_infos = el.debugging && el.debugging.quote_infos;
                                    // 给reference备注id index
                                    let references = el.debugging && el.debugging.references && el.debugging.references.map((m) => ({ ...m, id: m.index }));
                                    el.debugging.references = references || [];

                                    let content = el.debugging && el.debugging.display_content;
                                    if (quote_infos && quote_infos.length > 0) {
                                        el.display_content = that.handeLittleTagsData(quote_infos, references, content);
                                    } else {
                                        el.display_content = content || '';
                                    }
                                } else {
                                    let content = el.debugging && el.debugging.display_content;
                                    el.display_content = content || '';
                                }
                            });
                        }
                        findedMsg.agent_thought = data;

                        // console.error(
                        //     '【thought】-----all list--===============-->',
                        //     cache.chatsContent
                        // );
                        $e.$emit('client_msgContentChange', {
                            chatsContent: cache.chatsContent,
                            type: MESSAGE_TYPE.ANSWER
                        });
                    }

                    if (event.type === 'reference') {
                        let data = event.payload;
                        const findedMsg = that.getMsgById(data.record_id);

                        if (findedMsg) {
                            // 将问答类型的引用筛选出去
                            // 用户端需要展示 3（文档类型），后台只会返回 3
                            // 评测端后台会返回 1（问答类型）、2（文档分片类型），但本期不支持展示 1
                            findedMsg.references = data.references.filter((reference) => reference.type !== 1);

                            $e.$emit('client_msgContentChange', {
                                chatsContent: cache.chatsContent,
                                type: 'R' // ”参考来源“事件
                            });
                        }
                    }

                    if (event.type === 'error') {
                        let rep = event.payload || event;
                        if (rep && rep.error) {
                            // Vue.prototype.$message.error(rep.error.message || '服务出错了！');
                            Vue.prototype.$message(rep.error.message || '服务出错了！', 'error', null, 5000);
                        } else {
                            Vue.prototype.$message('服务出错了！', 'error', null, 5000);
                        }
                    }
                },
                onerror (error) {
                    console.error('【sse】Error:', error);
                }
            });
        } catch (error) {
            console.error('Failed to connect:', error);
        }
    };

    // 消息上行事件（用户端）
    async sseSendMsg (msg) {
        if (!cache.configInfo || !cache.configInfo.session_id) {
            await this.queryConfigInfo();
        }
        const requestId = uuidv4();
        console.log('【sse】sseSendMsg', msg, requestId);

        // 插入消息队列的数据
        const msgContent = {
            request_id: requestId,
            content: msg,
            is_from_self: true,
            timestamp: +new Date(),
            is_final: true, // 问题无流失，默认置为 true（即流式输出已结束）
            is_loading: true // 默认消息发送中
        };

        this.assembleMsgContent(msgContent, MESSAGE_TYPE.QUESTION);

        timeoutTasks[msgContent.request_id] = setTimeout(() => {
            this.assembleMsgContent({
                ...msgContent,
                failed: true
            }, MESSAGE_TYPE.ANSWER);
        }, msgSendTimeout);
        this.getQASse(msg, requestId);
    }
    // 组装消息队列数据
    // 问题确认消息：根据request_id关联覆盖（服务端收到问题后的确认消息）
    // 答案消息：倒序遍历插入（服务端答案消息）
    // assembleMsgContent (msgList, type) {
    //     let newMsg = msgList;

    //     if (type === MESSAGE_TYPE.QUESTION) {
    //         // 发送的问题消息由前端临时插入消息队列
    //         cache.chatsContent.push(newMsg);
    //     } else if (type === MESSAGE_TYPE.ANSWER) {
    //         if (cache.chatsContent.length < 1) {
    //             cache.chatsContent.push(newMsg);
    //         } else {
    //             let currentList = cache.chatsContent;

    //             timeoutTasks[newMsg.request_id] && clearTimeout(timeoutTasks[newMsg.request_id]);

    //             if (currentList.length === 2 && newMsg.can_rating) {
    //                 currentList[0].transferRobot = true;
    //             }
    //             if (newMsg.transfer && newMsg.loading_message) {
    //                 currentList.pop();
    //                 currentList[currentList.length - 1].loading_message = false;
    //                 currentList[currentList.length - 1] = {
    //                     ...newMsg,
    //                     ...currentList[currentList.length - 1],
    //                     transfer: true,
    //                     transferRobot: false
    //                 };
    //             } else {
    //                 for (let i = currentList.length - 1; i >= 0; i--) {
    //                     const { transfer, quit, transferRobot } = currentList[i];
    //                     const tmp = {
    //                         ...newMsg,
    //                         transfer,
    //                         quit,
    //                         transferRobot
    //                     };
    //                     // 按消息流式输出覆盖（record_id）
    //                     if (newMsg.record_id === currentList[i].record_id) {
    //                         currentList[i] = tmp;
    //                         break;
    //                     }
    //                     // 服务端问题消息确认数据，覆盖前端插入的临时问题消息数据（request_id匹配 & 自己发出的问题消息）
    //                     if (newMsg.request_id && newMsg.request_id === currentList[i].request_id && newMsg.is_from_self) {
    //                         newMsg.is_loading = false; // 服务端确认收到问题消息，则去除”发送中“状态
    //                         currentList[i] = tmp;
    //                         // 非人工状态时, 并且用户发送的不是敏感消息。插入临时[正在思考中...]消息
    //                         if (!newMsg.is_evil && !cache.transferInfo.transferStatus) {
    //                             currentList.push({
    //                                 loading_message: true,
    //                                 is_from_self: false,
    //                                 content: '',
    //                                 from_avatar: cache.configInfo.avatar,
    //                                 timestamp: Number(currentList[i].timestamp) // 精确到秒
    //                             });
    //                         }
    //                         break;
    //                     }
    //                     // 插入最新答案消息
    //                     if (Number(newMsg.timestamp) >= Number(currentList[i].timestamp)) {
    //                         if (currentList[i].loading_message) {
    //                             // 删除原来的[正在思考中...]消息
    //                             currentList[currentList.length - 1] = newMsg;
    //                         } else {
    //                             currentList.splice(i + 1, 0, newMsg);
    //                         }
    //                         break;
    //                     }
    //                     if (i === 0 && Number(newMsg.timestamp) < Number(currentList[i].timestamp)) {
    //                         currentList.splice(0, 0, newMsg);
    //                     }
    //                 }
    //             }
    //         }
    //     } else if (type === MESSAGE_TYPE.HISTORY) {
    //         let currentList = cache.chatsContent;
    //         // 历史数据打上标签，无需展示”重新生成“和”停止生成“操作
    //         msgList = msgList.map((r) => {
    //             return {
    //                 ...r,
    //                 is_history: true,
    //                 is_final: true
    //             };
    //         });

    //         if (currentList.length === 0) {
    //             // 若消息队列为空（用户端，初始拉取历史记录，用做判断欢迎页展示场景）
    //             cache.chatsContent = [].concat(msgList);
    //         } else {
    //             // 若消息队列不为空
    //             let oldMsgCurrent = currentList[0];
    //             let newMsgHistory = msgList[msgList.length - 1];

    //             // 将历史数据拼装到消息队列中（按照时间戳重排数据）
    //             if (Number(newMsgHistory.timestamp) < Number(oldMsgCurrent.timestamp)) {
    //                 cache.chatsContent = [].concat(msgList).concat(cache.chatsContent);
    //             } else {
    //                 msgList.reverse().forEach(msg => {
    //                     for (let i = 0; i < cache.chatsContent.length; i++) {
    //                         if (msg.record_id === cache.chatsContent[i].record_id) {
    //                             // 重复覆盖
    //                             cache.chatsContent[i] = msg;
    //                             break;
    //                         } else if (Number(msg.timestamp) <= Number(cache.chatsContent[i].timestamp)) {
    //                             cache.chatsContent.splice(i, 0, msg);
    //                             break;
    //                         } else if (i === cache.chatsContent.length - 1 && Number(msg.timestamp) > Number(cache.chatsContent[i].timestamp)) {
    //                             cache.chatsContent.splice(i + 1, 0, msg);
    //                         }
    //                     }
    //                 });
    //             }
    //         }
    //     }

    //     // 消息去重。同一record_id取最新，同时保留消息最早的时间戳
    //     cache.chatsContent = arrayUnique(cache.chatsContent, 'record_id', 'timestamp');

    //     // 消息队列变更通知事件
    //     $e.$emit('client_msgContentChange', {
    //         chatsContent: cache.chatsContent,
    //         type
    //     });
    // }

    // 组装消息队列数据
    // 问题确认消息：根据request_id关联覆盖（服务端收到问题后的确认消息）
    // 答案消息：倒序遍历插入（服务端答案消息）
    assembleMsgContent (msgList, type) {
        // console.log(
        //     'transfered transfered',
        //     type,
        //     clone(msgList),
        //     clone(cache.chatsContent)
        // );
        let newMsg = msgList;

        if (type === MESSAGE_TYPE.QUESTION) {
            // 发送的问题消息由前端临时插入消息队列
            cache.chatsContent.push(newMsg);
        } else if (type === MESSAGE_TYPE.ANSWER) {
            // console.log('transfered 1 transfered', type, clone(msgList), clone(cache.chatsContent));
            if (cache.chatsContent.length < 1) {
                cache.chatsContent.push(newMsg);
            } else {
                let currentList = cache.chatsContent;

                timeoutTasks[newMsg.request_id] &&
                        clearTimeout(timeoutTasks[newMsg.request_id]);

                if (currentList.length === 2 && newMsg.can_rating) {
                    currentList[0].transferRobot = true;
                }
                if (newMsg.transfer && newMsg.loading_message) {
                    console.log('newMsg.transfer && newMsg.loading_message');
                    currentList.pop();
                    currentList[currentList.length - 1].loading_message = false;
                    currentList[currentList.length - 1] = {
                        ...newMsg,
                        ...currentList[currentList.length - 1],
                        transfer: true,
                        transferRobot: false
                    };
                } else {
                    // console.log('transfered 2 transfered', type, currentList, clone(msgList), clone(cache.chatsContent));
                    const reqid = currentList.find((i) => {
                        return i.request_id === newMsg.request_id;
                    });
                    for (let i = currentList.length - 1; i >= 0; i--) {
                        const { transfer, quit, transferRobot } = currentList[i];
                        let tmp = {
                            ...newMsg,
                            transfer,
                            quit,
                            transferRobot
                        };
                        // 保留tokens_msg，防止覆盖
                        if (currentList[i].tokens_msg) {
                            tmp = { ...tmp, tokens_msg: currentList[i].tokens_msg };
                        }
                        // 保留thought 放置被覆盖
                        if (currentList[i].agent_thought) {
                            tmp = { ...tmp, agent_thought: currentList[i].agent_thought };
                        }
                        // 保留reference
                        if (currentList[i].references) {
                            tmp = { ...tmp, references: currentList[i].references };
                        }
                        // 按消息流式输出覆盖（record_id）
                        if (newMsg.record_id === currentList[i].record_id) {
                            console.log('按消息流式输出覆盖（record_id）');
                            // 澄清询问需要将链接摘出来当做问题交互
                            currentList[i] = {
                                ...tmp,
                                ...getClarifyQuestion(newMsg)
                            };
                            break;
                        }
                        // 服务端问题消息确认数据，覆盖前端插入的临时问题消息数据（request_id匹配 & 自己发出的问题消息）
                        // if (newMsg.request_id && newMsg.request_id === currentList[i].request_id && newMsg.is_from_self) {
                        //     console.log('案消息流式输出覆盖（record_id） newMsg.is_from_self');
                        //     newMsg.is_loading = false; // 服务端确认收到问题消息，则去除”发送中“状态
                        //     currentList[i] = tmp;
                        //     // 非人工状态时, 并且用户发送的不是敏感消息。插入临时[正在思考中...]消息
                        //     if (!newMsg.is_evil && !cache.transferInfo.transferStatus) {
                        //         currentList.push({
                        //             // show_search_engine: cache.configInfo.show_search_engine,
                        //             loading_message: true,
                        //             is_from_self: false,
                        //             content: '',
                        //             from_avatar: cache.configInfo.avatar,
                        //             // timestamp: Math.floor(+new Date() / 1000) // 精确到秒
                        //             timestamp: Number(currentList[i].timestamp) // 精确到秒
                        //         });
                        //     }
                        //     break;
                        // }
                        if (newMsg.request_id && newMsg.is_from_self) {
                            console.log(
                                '按消息流式输出覆盖（record_id） newMsg.is_from_self'
                            );
                            if (reqid && newMsg.request_id === currentList[i].request_id) {
                                newMsg.is_loading = false; // 服务端确认收到问题消息，则去除”发送中“状态
                                currentList[i] = tmp;
                            } else {
                                currentList.push(tmp);
                            }
                            // 非人工状态时, 并且用户发送的不是敏感消息。插入临时[正在思考中...]消息
                            if (!newMsg.is_evil && !cache.transferInfo.transferStatus) {
                                currentList.push({
                                    // show_search_engine: cache.configInfo.show_search_engine,
                                    loading_message: true,
                                    is_from_self: false,
                                    content: '',
                                    from_avatar: cache.configInfo.avatar,
                                    // timestamp: Math.floor(+new Date() / 1000) // 精确到秒
                                    timestamp: Number(currentList[i].timestamp) // 精确到秒
                                });
                            }
                            break;
                        }
                        // 插入最新答案消息
                        // TODO 修复正在思考中的问题。
                        console.log(
                            '清理正在思考的判断',
                            Number(newMsg.timestamp),
                            Number(currentList[i].timestamp)
                        );
                        if (Number(newMsg.timestamp) >= Number(currentList[i].timestamp)) {
                            console.log(
                                '按消息流式输出覆盖（record_id） newMsg.is_from_self'
                            );
                            if (currentList[i].loading_message) {
                                // 删除原来的[正在思考中...]消息
                                if (currentList[i].tokens_msg) {
                                    if (
                                        currentList[i].tokens_msg.record_id === newMsg.record_id
                                    ) {
                                        newMsg = {
                                            ...newMsg,
                                            tokens_msg: currentList[i].tokens_msg
                                        };
                                    }
                                }
                                console.error(
                                    'token_stat---del---loading------->',
                                    currentList[i],
                                    newMsg
                                );
                                currentList[currentList.length - 1] = newMsg;
                                // currentList.splice(i, 1, newMsg);
                            } else {
                                // console.error('token_stat---del---loading----2--->', currentList[i], newMsg);
                                currentList.splice(i + 1, 0, newMsg);
                            }
                            break;
                        }
                        if (
                            i === 0 &&
                                Number(newMsg.timestamp) < Number(currentList[i].timestamp)
                        ) {
                            // console.error('token_stat---del---loading---3---->', currentList[i], newMsg);
                            currentList.splice(0, 0, newMsg);
                        }
                    }
                }
            }
        } else if (type === MESSAGE_TYPE.HISTORY) {
            let currentList = cache.chatsContent;
            // 历史数据打上标签，无需展示”重新生成“和”停止生成“操作
            msgList = msgList.map((r) => {
                // let res = r.references.filter((reference) => reference.type !== 1).reduce((result, item) => {
                let res = r.references.reduce((result, item) => {
                    if (item.type === 4) {
                        result.push({ ...item, ids: [item.id] });
                    } else if (item.type === 1) {
                        result.push({ ...item, ids: [item.id] });
                    } else {
                        const existingItem = result.find(
                            (i) => i.doc_id === item.doc_id && i.type === item.type
                        );
                        if (existingItem) {
                            existingItem.ids.push(item.id);
                        } else {
                            result.push({ ...item, ids: [item.id] });
                        }
                    }
                    return result;
                }, []);

                if (r.quote_infos && r.quote_infos.length > 0) {
                    const quoteMock = r.quote_infos.reduce((acc, curr) => {
                        const existingItem = acc.find(item => item.position === curr.position);
                        let ret = {};
                        if (r && r.references && r.references.length > 0) {
                            ret = r.references.find(i => i.id === curr.index.toString());
                        }
                        if (existingItem) {
                            existingItem.tag.push({...ret, id: curr.index});
                        } else {
                            acc.push({
                                'tag': [{...ret, id: curr.index}],
                                'position': curr.position
                            });
                        }
                        return acc;
                    }, []);
                    r.quote_infos = quoteMock.sort((a, b) => b.position - a.position);
                    // 遍历数组，对每个元素进行操作
                    r.quote_infos.forEach(item => {
                        // 提取id数组并转换为字符串
                        const tagIds = item.tag.map(tag => tag.id);
                        const tagString = `[${tagIds.join(',')}](@ref)`;
                        // 在指定位置插入字符串
                        r.content = r.content.slice(0, item.position) + tagString + r.content.slice(item.position);
                    });
                }
                // 处理思考部分
                if (r.agent_thought && r.agent_thought.procedures && r.agent_thought.procedures.length > 0) {
                    r.agent_thought.procedures.forEach(el => {
                        el.show_type = this.getShowType(el);
                        if (this.getShowType(el) === 'search-reference') {
                            let quote_infos = el.debugging && el.debugging.quote_infos;
                            let references = el.debugging && el.debugging.references && el.debugging.references.map((m) => ({ ...m, id: m.index }));
                            el.debugging.references = references || [];

                            // let content = el.debugging && el.debugging.display_content;
                            // el.display_content = this.handeLittleTagsData(quote_infos, references, content);
                            let content = el.debugging && el.debugging.display_content;
                            if (quote_infos && quote_infos.length > 0) {
                                el.display_content = this.handeLittleTagsData(quote_infos, references, content);
                            } else {
                                el.display_content = content || '';
                            }
                        } else {
                            let content = el.debugging && el.debugging.display_content;
                            el.display_content = content || '';
                        }
                    });
                }

                if (
                    cache.app_type === APP_TYPE.CLASSIFYS &&
                        !r.is_from_self &&
                        r.type !== 6
                ) {
                    if (isJSON(r.content)) {
                        r.tags = JSON.parse(r.content);
                        r.content = '';
                    }
                }
                return {
                    ...r,
                    references: res,
                    is_history: true,
                    is_final: true
                };
            });
            console.log('0000000 msgList', msgList);

            if (currentList.length === 0) {
                // 若消息队列为空（用户端，初始拉取历史记录，用做判断欢迎页展示场景）
                cache.chatsContent = [].concat(msgList);
            } else {
                // 若消息队列不为空
                let oldMsgCurrent = currentList[0];
                let newMsgHistory = msgList[msgList.length - 1];

                // 将历史数据拼装到消息队列中（按照时间戳重排数据）
                if (
                    newMsgHistory &&
                        oldMsgCurrent &&
                        Number(newMsgHistory.timestamp) < Number(oldMsgCurrent.timestamp)
                ) {
                    cache.chatsContent = [].concat(msgList).concat(cache.chatsContent);
                } else {
                    msgList.reverse().forEach((msg) => {
                        for (let i = 0; i < cache.chatsContent.length; i++) {
                            if (msg.record_id === cache.chatsContent[i].record_id) {
                                // 重复覆盖
                                cache.chatsContent[i] = msg;
                                break;
                            } else if (
                                Number(msg.timestamp) <= Number(cache.chatsContent[i].timestamp)
                            ) {
                                cache.chatsContent.splice(i, 0, msg);
                                break;
                            } else if (
                                i === cache.chatsContent.length - 1 &&
                                    Number(msg.timestamp) > Number(cache.chatsContent[i].timestamp)
                            ) {
                                cache.chatsContent.splice(i + 1, 0, msg);
                            }
                        }
                    });
                }
            }
        }

        // 消息去重。同一record_id取最新，同时保留消息最早的时间戳
        cache.chatsContent = arrayUnique(
            cache.chatsContent,
            'record_id',
            'timestamp'
        );

        console.log('==【用户端】消息队列 == \n', {
            chatsContent: cache.chatsContent,
            type
        });

        // 消息队列变更通知事件
        $e.$emit('client_msgContentChange', {
            chatsContent: cache.chatsContent,
            type
        });
    }

    // // todo 停止生成回复
    stopGeneration () {
        const ongoingMsg = cache.chatsContent.find((r) => r.is_final === false);
        if (!ongoingMsg) return;

        if (sseObj) {
            // 关闭sse，停止生成回复
            sseObj.close();
        }
        this.modifyMsgContent(ongoingMsg.record_id);
    }
}

const $sse = new SseCls();
Vue.prototype.$SseCls = $sse;
export default $sse;
